 |
|
| If you can't view the Datasheet, Please click here to try to view without PDF Reader . |
|
|
|
| If you can't view the Datasheet, Please click here to try to view without PDF Reader . |
|
|
| Datasheet File OCR Text: |
| CoreFIR Finite Impulse Response (FIR) Filter Generator Product Summary Intended Use * Finite Impulse Response (FIR) Filter for Actel FPGAs * Core Deliverables * Evaluation Version - RTL Code of a Sample Filter and Compiled RTL Simulation Model Fully Supported in the Actel Libero(R) Integrated Design Environment (IDE) A Microsoft Windows(R) Binary Executable of the CoreFIR Generator VHDL FIR Module VHDL Test Harness Key Features * Core Generator - - * Executable File Outputs Run-Time Library (RTL) Code and Testbench Based on Input Parameters Self-Checking - Executable Tests Generated Output against Algorithm Multiplier-Free Computation Low Cost Optimized for Actel FPGAs Serialized Computation when System Clock Rate is Faster than the Data Sample Rate Lookup Tables Utilize Embedded RAMs RTL Version - - - Distributed Arithmetic (DA) Algorithm - - - Synthesis and Simulation Support * Synthesis: Synplicity(R), Synopsys(R) (Design (R) TM/FPGA Compiler ExpressTM), Compiler /FPGA ExemplarTM Simulation: OVI-Compliant Verilog Simulators and Vital-Compliant VHDL Simulators * * Folding Architecture to Minimize Design Size - Contents Device Utilization and Performance ......................... 2 FIR Filter Using Distributed Arithmetic Algorithm ... 3 General Description ................................................... 5 Functional Block Description ..................................... 5 I/O Signal Description ................................................ 6 CoreFIR Generator Parameters .................................. 7 FIR Filter with Large Number of Taps ....................... 8 Clock and Reset ........................................................ 11 Input and Output Timing ........................................ 11 Appendix I: Sample Configuration File ................... 12 Ordering Information .............................................. 13 List of Changes ......................................................... 13 Datasheet Categories ............................................... 13 * * * * * * * * Efficient Structure Using Embedded RAMs - On-Chip DA Lookup Table Generator for FPGA with Embedded RAMs Embedded RAMs Initialized as DA Lookup Table DA Lookup Table ROM Synthesis for FPGA without Embedded RAMs Multiple DA lookup Tables to Split Large Number of Taps Actel FPGA-Optimized RTL Code Supports 2 to 128 Taps 1- to 32-Bit Input Data and Coefficient Precision Supported Families * * * * * * * Fusion ProASIC3/E ProASICPLUS (R) Axcelerator(R) RTAX-S SX-A RTSX-S December 2005 (c) 2005 Actel Corporation v 3 .0 1 CoreFIR Device Utilization and Performance The CoreFIR generates FIR filters with many configurations. Table 1 provides the typical utilization and performance data for the generated FIR filters implemented with the configurations listed in Table 2 on page 3. Refer to Table 2 on page 3 for the Configuration column in Table 1. Table 1 * CoreFIR Device Utilization and Performance Cells or Tiles Family Fusion Fusion Fusion Fusion Fusion Fusion ProASIC3 ProASIC3 ProASIC3 ProASIC3 ProASIC3 ProASIC3 ProASICPLUS ProASICPLUS ProASICPLUS ProASICPLUS ProASICPLUS Axcelerator Axcelerator Axcelerator Axcelerator Axcelerator Axcelerator RTAX-S RTAX-S RTAX-S RTAX-S RTAX-S RTAX-S SX-A SX-A SX-A RTSX-S RTSX-S RTSX-S Configuration 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 1 2 3 Combinatorial 454 1410 3080 5511 7089 24356 454 1410 3080 5511 7089 24356 558 2054 3540 6391 8775 229 693 1231 2249 3129 9132 229 693 1231 2249 3129 9132 386 1115 1831 381 1115 1831 Sequential 129 375 679 935 1708 3718 129 375 679 935 1708 3718 116 427 661 872 1606 148 478 719 852 1704 3355 148 478 719 852 1704 3355 159 480 727 159 480 727 Total 583 1784 3759 6446 8797 28074 583 1785 3759 6446 8797 28074 674 2481 4201 7271 10381 377 1171 1950 3101 4833 12487 377 1171 1950 3101 4833 12487 545 1595 2558 540 1595 2558 RAM Blocks 0 0 0 8 0 45 0 0 0 8 0 45 0 0 0 8 0 0 0 0 4 0 32 0 0 0 4 0 32 0 0 0 0 0 0 Utilization Device AFS060 AFS250 AFS250 AFS600 AFS600 AFS1500 A3P060 A3P125 A3P1000 A3P1000 A3P1000 A3P1500 APA075 APA150 APA1000 APA1000 APA750 AX125 AX250 AX250 AX500 AX1000 AX2000 RTAX1000S RTAX1000S RTAX1000S RTAX1000S RTAX1000S RTAX2000S A54SX16A A54SX72A A54SX72A RT54SX32S RT54SX72S RT54SX72S Total 38% 29% 61% 47% 64% 73% 38% 58% 15% 26% 36% 73% 22% 40% 8% 13% 32% 19% 28% 46% 38% 27% 39% 2% 6% 11% 17% 27% 39% 38% 26% 42% 19% 26% 42% Performance MHz 69 56 52 45 40 31 69 56 52 45 40 31 29 19 19 17 13 174 110 111 74 73 46 114 76 66 41 45 29 112 64 63 52 36 36 Notes: 1. The data above are obtained by typical synthesis and place-and-route methods. Other core parameters can result in different utilization and performance. 2. Cell (tile) count may vary depending on the actual coefficient values. 2 v3.0 CoreFIR Table 2 * Test Configurations Configuration 1 2 3 4 5 nbits_input 8 16 12 12 16 nbits_coef 16 16 15 15 15 ntaps 8 16 32 32 64 fpga_family All All All AX, RTAX-S, APA All coef_fixed 1 1 1 0 1 6 16 16 128 AX, RTAX-S, APA 0 FIR Filter Using Distributed Arithmetic Algorithm Distributed Arithmetic Algorithm Overview FIR filters are used in applications that require exact linear phase response. Typical applications for a FIR filter include: image processing, digital audio, digital communication, and biomedical signal processing. A FIR filter is defined in EQ 1: ntaps - 1 y[n] = 0 c[n] x x[n] EQ 1 where: c[n] = h[ntaps - n -1] and h is the impulse response. The term ntaps is short for number of taps. In summary, the direct computation for one point of FIR requires: ntaps multiplications + (ntaps-1) additions. Distributed Arithmetic (DA) is a well-known method for eliminating resources in multiply-and-accumulate structures (MACs) implementing digital signal processing (DSP) functions. DA trades memory for combinatory elements, resulting in an efficient implementation in FPGAs. Another feature of DA is its easy serialization of the input, which further reduces the cost of operation when FIR data rate is low compared to the system clock, a common scenario in FIR applications. The input of a FIR can be expressed in the composition of its bits, as shown in EQ 2: x[n] = nbits_in - 1 0 x[n][b] x 2 b EQ 2 where x[n][b] is the bth bit of x[n] and nbits_in is the number of bits of input. The resulting output of the FIR filter is shown in EQ 3: ntaps - 1 y[n] = 0 ntaps - 1 c[n] x[n] = 0 nbits_in - 1 c[n] 0 x[n][b]2 b EQ 3 Changing the summation order gives the results shown in EQ 4: nbits_in - 1 y[n] = 0 2 b ntaps - 1 0 nbits_in - 1 c[n] x[n][b] = 0 2 T(X[b]) b EQ 4 v3.0 3 CoreFIR ntaps - 1 where: T(X[b]) = 0 c[n] x[n][b] and X[b] is a collection of the bth bits of ntaps different taps. Note that the x[n][b] can only be 0 or 1. There are 2ntaps different values of T. If T is pre-calculated and stored inside a RAM or ROM, the FIR computation becomes nbits_in table lookup operations using x[b] and nbits_in-1 additions. Multiplication operations are eliminated. In summary, the FIR computation using DA for one point of FIR requires: nbits_in table lookups + (nbits_in-1) additions. The cost to eliminate multiplication is a memory block to store 2ntaps pre-computed values. The serialization of table lookup and addition is possible because table T is the same for each b. If one table lookup and one addition can be finished in one cycle, the total computation will finish in b cycles. The serialization of the FIR introduces further opportunity to reduce the size of the design, which is the key to an efficient FPGA design. The expression x[n][b] represents the bth bit of input x[n]. In the example, in the first cycle, all 0th bits of input x[n] to x[n-3] are fed into the lookup table as an input address; in the second cycle, all 1st bits of inputs input x[n] to x[n-3] are fed into the lookup table; in the third cycle, all 2nd bits of inputs input x[n] to x[n-3] are fed into the lookup table; and in the fourth cycle, all 3rd bits of inputs input x[n] to x[n-3] are fed into the lookup table. The shifter shifts the outputs of the lookup table for the inputs of the adder, which accumulates for the final result. Example Design of a FIR Filter Using DA An example of a FIR with four taps (ntaps = 4) and four bits for inputs (nbits_in = 4) is shown in Figure 1. x[n][3] x[n-1][3] x[n-2][3] x[n-3][3] x[n][2] x[n-1][2] x[n-2][2] x[n-3][2] x[n][1] x[n-1][1] x[n-2][1] x[n-3][1] x[n][0] x[n-1][0] Lookup Table x[n-2][0] x[n-3][0] Shifter Flow Control Adder Reg Figure 1 * Example Implementation of a Bit-Serialized FIR Using DA The serialized DA implementation in Figure 1 uses a table lookup with 16 words, and takes four clock cycles to finish one FIR point. 4 v3.0 CoreFIR Storage and Large Number of Taps As seen in the previous section, the size of the lookup table is 2ntaps, which is exponentially increased with more ntaps. A design with a large number of taps needs to have several lookup tables. Let ntaps = p x q. If we split taps into p groups, each group has q taps. Then the FIR becomes as shown in EQ 5: nbits_in - 1 y[n] = 0 2 b n=ntaps - 1 0 c[n] x[n][b] = nbits_in - 1 b 0 n=pq - 1 2 0 c[n] x[n][b] EQ 5 By splitting ntaps into two level summations, we have the result shown in EQ 6: y[n] = nbits_in - 1 b 0 i=p-1 j=q-1 2 0 0 c[iq + j] x[iq + j][b] EQ 6 Refer to "FIR Filter with Large Number of Taps" on page 8 for further information. General Description The CoreFIR is an Actel FPGA-optimized RTL generator that produces a finite impulse response filter. It implements the DA algorithm to eliminate multiplication for faster and smaller designs. The CoreFIR is a generator which utilizes Actel FPGA's embedded RAM blocks as DA lookup tables (when available) to further reduce the size of the design. The generator also reads the user system clock rate and data sample rate to explore using a folding or serial architecture to further reduce size, especially when the system clock rate is much greater than the data sampling rate. The generator automatically switches to the use of multiple DA lookup tables when the requested FIR filter has a large number of taps. Figure 2 shows the functional block diagram of a generated FIR filter design. More complex designs may contain multiple lookup tables, accumulators, or control sections. datai Coefficients Input Buffers DA Lookup Tables (RAMs or ROM) DA LUT Generator Control Shifter Accumulator datao Figure 2 * Functional Block Diagram Functional Block Description The functional blocks shown in Figure 2 illustrate the architecture of the generated FIR filter using the DA algorithm. v3.0 5 CoreFIR Input Buffers The Input Buffers block stores the input data which contains ntaps data points, where ntaps is the number of taps of the FIR filter. The Input Buffers block also circulates the data bits to address the DA Lookup Tables (LUTs) required by the DA algorithm. An optional function of the input buffers block is to share its storage with the DA LUT generator. The coefficients used in computing the LUT content can be stored in the input buffers when a design uses the embedded RAM blocks for the LUTs. DA LUT Generator The DA LUT Generator computes the LUT contents required by the distributed arithmetic algorithm. It reads the coefficients from the Input Buffers block and writes the LUT words into the embedded RAM blocks. These blocks are available only for designs that use embedded RAM blocks as LUTs. The DA LUT Generator produces LUT contents for multiple LUTs when implementing a FIR filter with variable coefficients. Refer to "DA LUT Generation" on page 10 and "I/O Timing Diagram of LUT Initialization" on page 11 for detailed information on initialization of the DA LUT. DA Lookup Tables (LUTs) The DA LUTs store the LUT contents for the distributed algorithm. The generator implements the DA LUTs in two ways: (1) synthesized ROM using FPGA cells; and (2) embedded RAM blocks supported by the on-chip DA LUT Generator. The first method is for an FPGA without embedded RAM blocks, intended primarily for a small FIR filter. The latter is for an FPGA with embedded RAM blocks. FIR filters with a large number of taps may require multiple LUTs. Control The state machine inside the Control block controls the operations of all other blocks. It controls the input buffers to ensure they operate based on the specified system clock rate and sample rate, monitors input enable and coefficient input enable, and circulates input data bits to address the DA LUTs. It also controls the shifters and accumulators to ensure they operate based on the requested FIR configuration and DA algorithm. The Control block coordinates the initialization of the LUTs by the DA LUT generator when using embedded RAMs. The Control logic is designed to support folding or serialization of computation when the system clock rate is substantially higher than the data sampling rate. Shifter and Accumulator The Shifter and Accumulator perform additions with LUT outputs and the alignments of LUT outputs required by the DA algorithm. Multiple accumulators and shifters may be needed to implement a FIR filter with a large number of taps. I/O Signal Description The FIR filter generated by the CoreFIR Generator consists of the I/O signals defined in Table 3 (see Figure 3 on page 7). Table 3 * I/O Signal Description I/O Signal clk rstn datai_en datai1 datao_valid datao coefi_en2 ready2 Notes: 1. Input datai is also the input for coefficients for design using embedded RAMs as DA LUTs. In this case the width can be the maximum of nbits_in and nbits_coef. 2. Ports coefi_en and ready are only available when coef_fixed = 0. 3. Refer to "Number of Bits of Output (nbits_out)" on page 8 for details. 4. Refer to Table 4 for nbits_in and nbits_coef. Direction Input Input Input Input Output Output Input Output Width 1 1 1 nbits_in1 1 nbits_out3 1 1 Polarity N/A Active low Active high N/A Active high N/A Active high Active high Description Master clock, positive edge Master reset, asynchronous Input data enable Input data or coefficients1 Output data valid Output data Coefficient input enable Ready to input datai 6 v3.0 CoreFIR clk rstn datai_en datai datao_valid coefi_en* FIR datao_valid datao ready* Note: *coefi_en and ready are available when coef_fixed = 0. Figure 3 * I/O Signals CoreFIR Generator Parameters The CoreFIR generates the RTL code for FIR filters with a variety of parameters. These parameters include generic FIR parameters such as number of taps, number of input's bits, number of coefficients' bits, and data type, as well as implementation parameters such as FPGA family, use embedded RAMs, system clock rate, and data sampling rate. The CoreFIR supports the variations specified in Table 4. Table 4 * CoreFIR Generator Configuration Parameters Recommended Selection Parameter Name module_name nbits_input nbits_coef ntaps tap data_signed fpga_family coef_fixed sys_clk_frq sample_ratio Module_lang Description Name of generated module Number of input's bits of data Number of coefficients' bits of data Number of taps Array of coefficients Data type: 0 = unsigned, 1 = signed FPGA family 0 = filter with configurable coefficients 1= filter with fixed coefficients Input clock frequency Sampling rate = sys_clk_frq/sample_ratio Reserved. VHDL only. AX - 2 - 24 2 - 24 2 - 128 - 0,1 ax - - APA - 2 - 24 2 - 24 2 - 64 - 0,1 apa - - SX-A - 2 - 24 2 - 24 2 - 32 - 0,1 sxa - - nbits_in VHDL nbits_in VHDL nbits_in VHDL Refer to "Appendix I: Sample Configuration File" on page 12 for a sample usage of the parameters shown in Table 4 in a configuration file for the CoreFIR Generator. Detailed discussions about these parameters are in the sections of this datasheet that follow. Number of Bits of Inputs (nbits_in) and Coefficients (nbits_coef) The FIR Generator supports the number of bits of inputs and coefficients for the device families specified in Table 4. These parameters are set with the variables nbits_in and nbits_coef in the configuration file. Refer to "Appendix I: Sample Configuration File" on page 12 for details. Number of Taps (ntaps) The FIR generator supports the number of taps specified by the device families in Table 4. The variable ntaps in the configuration file specifies the setting of this parameter. Refer to "Appendix I: Sample Configuration File" on page 12 for details. v3.0 7 CoreFIR Number of Bits of Output (nbits_out) The FIR Generator supports only full precision computation. Thus, the number of bits of output is determined by the number of input's and coefficients' bits for the device family as specified in Table 4 on page 7. The number of bits of output are specified by EQ 7: nbits_out = nbits_in + nbits_coef + ceil(log2(ntaps)) - 1 EQ 7 specified with the unit of MHz. Refer to Table 4 on page 7 and "Appendix I: Sample Configuration File" on page 12 for details. Sample Ratio (sample_ratio) The FIR Generator supports a configuration parameter, sample_ratio, which specifies the sampling rate against the system clock frequency. It defines that the data sampling rate is equal to sys_clk_frq/sample_ratio. This parameter provides guidance to implement a folding architecture to reduce the size of the design. The configuration parameter sample_ratio can only be a positive integer greater than 1. Refer to Table 4 on page 7 and "Appendix I: Sample Configuration File" on page 12 for details. where ceil is the ceiling function of a floating point data. Asymmetric FIR and Symmetric FIR The FIR generator supports an asymmetric FIR filter only. Symmetric FIR filters will be supported in future releases. Embedded RAM as LUTs (coef_fixed) The FIR Generator utilizes a switch that determines whether to implement DA LUTs by embedded RAM blocks or by synthesized ROM using FPGA cells. The LUTs are implemented by synthesized ROM using FPGA cells when coef_fixed is equal to 1. The LUTs are implemented by embedded RAM blocks available for Axcelerator, ProASICPLUS, and ProASIC3 devices when coef_fixed is equal to 0. This setting may be set to 1 for a filter design with fixed coefficients for an FPGA device with embedded RAM such as AX, RTAX-S, APA, and PA3, since the overhead of the DA LUT Generator overrides the benefits of using an embedded RAM block as a LUT. The coef_fixed configuration parameter is valid only when the configuration parameter fpga_family is set to ax, apa, or pa3. Refer to Table 4 on page 7 and "Appendix I: Sample Configuration File" on page 12 for details. Module Name (module_name) The FIR Generator supports a configuration parameter, module_name, that specifies the name of the generated module. The generated testbench has the name FPGA Family (fpga_family) The FIR Generator supports a configuration parameter, fpga_family, that specifies the targeted Actel FPGA device family. The options are ax, apa, pa3, and sxa. The option for RTAX-S is ax. The option for RTSX-S is sxa. Refer to Table 4 on page 7 and "Appendix I: Sample Configuration File" on page 12 for details. Signed/Unsigned Inputs and Coefficients (data_signed) The FIR Generator supports signed or unsigned operations. The generator supports two cases: both input and coefficient are unsigned, or both input and coefficient are signed. It supports an unsigned implementation when the configuration parameter data_signed is equal to 0, and a signed implementation when the configuration parameter data_signed is equal to 1. Refer to Table 4 on page 7 and "Appendix I: Sample Configuration File" on page 12 for details. Architecture Variations The DA algorithm for FIR provides an excellent solution, but also introduces many variations on the design architecture due to limitations of the FPGA resource. FIR Filter with Large Number of Taps As illustrated in section "FIR Filter Using Distributed Arithmetic Algorithm" on page 3, the number of words of the DA LUT is 2ntaps, which is exponentially increased with ntaps. A LUT splitting method, as defined in "Storage and Large Number of Taps" on page 5, effectively reduces the memory usage. The CoreFIR Generator utilizes this method to reduce the memory usage. It usually splits the coefficients into eight or nine taps for each LUT when embedded RAM blocks are available. System Clock Frequency (sys_clk_frq) The FIR Generator reads in the system clock frequency via configuration parameter sys_clk_frq. The generated testbench assigns this frequency to its clock generation. The generated design runs at this frequency inside the test bench. The configuration parameter should be 8 v3.0 CoreFIR An example of the split lookup table implementation of a FIR with eight taps (ntaps = 8) and four bits for inputs (nbits_in = 4) is shown in Figure 4. In the example, eight taps have been split into two groups. Each has four taps, and each group addresses separate lookup tables. This differs from the case in Figure 1 on page 4, which only has one LUT. x[n][3] x[n-1][3] x[n-2][3] x[n-3][3] x[n-4][3] x[n-5][3] x[n-6][3] x[n-7][3] x[n][2] x[n-1][2] x[n-2][2] x[n-3][2] x[n-4][2] x[n-5][2] x[n-6][2] x[n-7][2] x[n][1] x[n-1][1] x[n-2][1] x[n-3][1] x[n-4][1] x[n-5][1] x[n-6][1] x[n-7][1] x[n][0] x[n-1][0] x[n-2][0] x[n-3][0] x[n-4][0] x[n-5][0] Lookup Table x[n-6][0] x[n-7][0] Shifter Shifter Lookup Table Flow Control Adder Reg Adder Reg Adder Output Figure 4 * Example of Split Lookup Table Implementation Folding The system clock rate of many FIR filter systems is a multiple of the data rate (or data sampling rate). For typical FPGA implementation, the size of the design is key for efficient implementation. Thus, exploitation of the ratio between the system clock rate and data rate is an effective approach to reduce the size of the design. In other words, folding or serialization of the computation can reduce the size of the design. The DA algorithm for FIR introduces bit-serialization of the operations. This property of the DA can be very efficient for exploring the ratio between system clock rate and data rate. If the number of bits of input is nbits_in, it takes nbits_in table lookup and additions to finish one output point of the FIR. If the system clock rate is nbits_in times faster than data rate, the serialization of table lookup and additions is done with the optimized timing. The parameter sample_ratio defines the ratio between the system clock rate (sys_clk_frq) and the data sampling rate (data_rate), as shown in EQ 8: sample_ratio = sys_clk_frq/data_rate EQ 8 CoreFIR supports folding when sample_ratio is greater than or equal to nbits_in. The serialized operations of table lookup and addition are done in nbits_in clock cycles of the system clock, and the design is idle during the rest of sample_ratio and nbits_in cycles. The generator only requires that the sample_ratio be an integer; the system clock rate is an exact multiple of the data rate. Future releases may support a sample_ratio less than nbits_in. v3.0 9 CoreFIR DA LUTs Using FPGA Cells Some Actel FPGA families such as SX-A and RTSX-S do not have an embedded RAM implementation. In this case, the CoreFIR Generator requires that the lookup table be hard-coded as ROM using FPGA cells. This configuration does not need the DA LUT Generator shown in Figure 2 on page 5. The generator selects this configuration when the configurable parameter coef_fixed is set to 1 or the configuration parameter fpga_family is not one of ax, apa, or pa3. DA LUTs Using Embedded RAM Blocks Many Actel FPGA families have embedded RAM blocks. The FIR generator takes advantage of these embedded RAM blocks, and the DA LUTs are implemented using these embedded RAM blocks. This configuration requires additional overhead in that the embedded RAM blocks must be initialized by a DA LUT Generator as shown in Figure 2 on page 5. The generator selects this configuration when the configurable parameter coef_fixed is set to 0 and the configuration parameter fpga_family is set to ax, apa, or pa3. when the configuration parameter coef_fixed is set to 0. After the reset is complete, the DA LUT Generator will wait for the Input Buffers block to signal that the coefficients are loaded into the input buffers. Then the DA LUT generator will compute the LUT words and write them into the embedded RAM blocks. The DA LUT Generator produces LUT contents for multiple LUTs when implementing a FIR filter with a large number of taps. The generator has only one computation engine, and initializes multiple LUTs sequentially. After the initialization of the RAM blocks, the output ready will go high to let the system know that the FIR filter is ready to accept data. Input Buffering Scheme The Input Buffers block always performs the functions defined in "Input Coefficients" on page 10, but only performs functions defined in "Input Data" on page 10 when the embedded RAM blocks are used as the DA LUTs (when coef_fixed is set to 1). Input Data The input dataflow is designed to use the scheme shown in Figure 5 to reduce the size of registers. The horizontal movement of the input ensures the bits of the inputs feed into the lookup table, and that it happens at every cycle. Vertical movement of input data only occurs as the most significant bit (MSB) is fed into lookup table, when it switches to the next FIR data point. DA LUT Generation The DA LUT Generator computes the LUT contents of the distributed arithmetic algorithm. It reads the coefficients from the Input Buffers block and writes the LUT words into the embedded RAM blocks. This block is only available when using embedded RAM blocks as LUTs - x[n][3] x[n-1][3] x[n-2][3] x[n-3][3] Figure 5 * Example of Input Buffering Scheme x[n][2] x[n-1][2] x[n-2][2] x[n-3][2] x[n][1] x[n-1][1] x[n-2][1] x[n-3][1] x[n][0] x[n-1][0] x[n-2][0] x[n-3][0] Input Coefficients The CoreFIR generator shares the input buffers for coefficients input when embedded RAM blocks are used as the DA LUTs. The configuration parameter coef_fixed is set to 0. In this configuration, the width of the input datai is the maximum of nbits_in and nbits_coef. The input datai reads in coefficients when input coefi_en is high. After enough coefficients are fed into the buffer, coefi_en is ignored and the coefficients stay inside the input buffers until the DA LUT Generator finishes the initialization of the embedded RAM blocks. User Interface The generator executable reads one command line parameter, which is the name of the configuration file. It generates RTL code for the module and testbench based on the parameters in the configuration file. Refer to Table 4 on page 7 and "Appendix I: Sample Configuration File" on page 12 for details of the configuration file. 10 v3.0 CoreFIR Clock and Reset Clock The CoreFIR generates a FIR filter design that uses only positive-edge-triggered registers. The entire design is fully synchronized using the positive edge of the input clock clk, including the embedded RAM blocks (when available). Input and Output Timing I/O Timing Diagram of Normal FIR Operation The I/O timing under normal FIR operation is illustrated in Figure 6. The labels s0 and s2 refer to the data sampling point for input data, while s1 is the sampling point for output data. Due to variations of the configuration, you should refer to comments in the generated module for t0 and t1. These parameters are given in the number of the clock cycles of the input clock, clk. Reset The CoreFIR generates a design that uses only one active low asynchronous reset. The entire design is asynchronously reset by the input rstn. s0 t1 t0 s1 s2 clk datai_en datai 0 1 datao_valid datao 0 Figure 6 * I/O Timing Diagram of Normal FIR Operation I/O Timing Diagram of LUT Initialization The I/O timing for LUT initialization is illustrated in Figure 7. In this figure, s0 and s1 are the starting and ending points for feeding coefficients, while s2 is the sampling point for output ready. Due to the variation of the configuration, refer to the comments inside the generated module for t2, which are given in the number of the clock cycles of the input clock clk. s0 t2 s1 s2 clk coefi_en datai 0 1 2 ntaps-1 ready Figure 7 * I/O Timing Diagram for LUT Initialization v3.0 11 CoreFIR Appendix I: Sample Configuration File The following shows a sample configuration file. module_name nbits_input nbits_coef ntaps tap data_signed fpga_family coef_fixed sys_clk_frq sample_ratio module_lang firtest 8 5 13 8 14 21 27 31 31 27 21 14 8 4 2 1 0 ax 1 25 16 vhdl 12 v3.0 CoreFIR Ordering Information Order CoreFIR through your local Actel sales representative. Use the following numbering convention when ordering: CoreFIR-XX, where XX is listed in Table 5. Table 5 * Ordering Codes XX EV AR UR Description Evaluation Version RTL for unlimited use on Actel devices RTL for unlimited use and not restricted to Actel devices List of Changes The following table lists critical changes that were made in the current version of the document. Previous Version Changes in Current Version (v 3 .0 ) v2.1 The "Supported Families" section was updated to include Fusion. Table 1 was updated to include Fusion data. v2.0 The "Supported Families" section was updated. Table 1 was updated. Page 1 2 1 2 Datasheet Categories In order to provide the latest information to designers, some datasheets are published before data has been fully characterized. Datasheets are designated as "Product Brief," "Advanced," and "Production." The definitions of these categories are as follows: Product Brief The product brief is a summarized version of an advanced or production datasheet containing general product information. This brief summarizes specific device and family information for unreleased products. Advanced This datasheet version contains initial estimated information based on simulation, other products, devices, or speed grades. This information can be used as estimates, but not for production. Unmarked (production) This datasheet version contains information that is considered to be final. v3.0 13 Actel and the Actel logo are registered trademarks of Actel Corporation. All other trademarks are the property of their owners. www.actel.com Actel Corporation 2061 Stierlin Court Mountain View, CA 94043-4655 USA Phone 650.318.4200 Fax 650.318.4600 Actel Europe Ltd. Dunlop House, Riverside Way Camberley, Surrey GU15 3YL United Kingdom Phone +44 (0) 1276 401 450 Fax +44 (0) 1276 401 490 Actel Japan www.jp.actel.com EXOS Ebisu Bldg. 4F 1-24-14 Ebisu Shibuya-ku Tokyo 150 Japan Phone +81.03.3445.7671 Fax +81.03.3445.7668 Actel Hong Kong www.actel.com.cn Suite 2114, Two Pacific Place 88 Queensway, Admiralty Hong Kong Phone +852 2185 6460 Fax +852 2185 6488 51700056-2/12.05 |
Price & Availability of COREFIR-AR
 |
|
|
|
|
All Rights Reserved © IC-ON-LINE 2003 - 2022 |
| [Add Bookmark] [Contact Us] [Link exchange] [Privacy policy] |
|
Mirror Sites : [www.datasheet.hk]
[www.maxim4u.com] [www.ic-on-line.cn]
[www.ic-on-line.com] [www.ic-on-line.net]
[www.alldatasheet.com.cn]
[www.gdcy.com]
[www.gdcy.net] |